#include <reg552.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <rtx51.h>

#define	WFE				0xFF
#define	EndWait		0x05			//Ako dlho cakam na mailbox ....

#define	REGK			0					//Externa teplota okolia pre kurenie a je tam aplikovana vykurovacia krivka ....
#define	REGV			1
#define	EXH2OIN		2
#define	EXTEMP		3
#define	INTEMP		4					//Interna teplota regulatora na doske s mikroprocesorom pre diagnosticke ucely 0C az 100C ...
#define	MEASURE		5

#define	CLOCK			9
#define	SERVOK		10
#define	SERVOV		11
#define	KEYBOARD	12

enum {Zero=0, Min=-1, Max=+1, Deathtime=+30, Yes='Y', No='N'};
enum {regk=0x0000, regv=0x1000, h2oin=0x2000, mask=0x0FFF} Tags;
enum {READ=0x80, WRITE=0x40} E2Prom_State;

#define AddrDS1624A	0x90							//Adresa pre DS1621,DS1624,DS1631 - tzv. CONTROL_BYTE
#define AddrAT24c32	0xA0							//Adresa pre AT24C08 az AT24C64 - tzv. CONTROL_BYTE

extern unsigned char Read_Eprom_AT24C32(unsigned char, unsigned int);
extern void Write_Eprom_AT24C32(unsigned char, unsigned int, unsigned char);
extern signed char Get_Int_Temp(unsigned char);
extern code volatile signed char Ekviterm[14][101];

typedef xdata struct
{
 unsigned char Hod,Min,Sek,Sto,Den,Mes;
 unsigned int Rok;
}
Interval;

typedef struct																							//Predtym bolo len "typedef struct" a nefungovalo to dobre ... !!!
{
 char Reset;
 int SetPosition,ActualPosition,dPosition;
 int E0,E1,E2;
 int Servo_Min,Servo_Max,Hysterezia;
 int Tkomfort,Tutlm,deltaT,Tmin,Tmax,Tlimit;
 unsigned char dT;
 float Kp,Ti,Td,KA,KB,KC,Y0,Y1;
 unsigned char Comfort,Pump,Vykurovacia_Krivka;
 Interval Od[7],Do[7];
}
volatile Parameter;

#define NumMemBlocks	2+1																			//Definujem [n] pouzitych pamatovych blokov, aby nerobilo chyby musi byt o jeden alokovany blok viac !?
#define	SizeMemBlock	sizeof(Parameter)												//Velkost pouzivaneho packetu v strukture ...
#define	SizeMemPool		(NumMemBlocks)*(2+SizeMemBlock)					//(Header+sizeof(AD_Converter)*n)

xdata unsigned char 	MemoryPool[SizeMemPool];								//MemoryPool je niekedy lepsie definovat na pevnej adrese ale uVision robi problemy pri simulacii, doslova vypne niektore tasky akoby pretiekla pamat a poskodila enviroment ...

xdata	Parameter	*RegK,*RegV,*BakX;
xdata Interval Cas = {6,15,55,50};
xdata signed char IntTemp;
xdata int AD[8];

#include <parametre.inc>
#include <tabulky1.inc>

void Clock(void) _task_ CLOCK _priority_ 1
{
 signed char RtxCompletion;
 os_set_slice(1536);
 RtxCompletion=os_create_pool(SizeMemBlock,MemoryPool,SizeMemPool); 				//Vytvorim MemoryPool v pamati XRAM pre datove struktury ...
 RtxCompletion=os_create_task(MEASURE);
 RegK=os_get_block(SizeMemBlock);
 RegV=os_get_block(SizeMemBlock);
 BakX=os_get_block(SizeMemBlock);																						//ptr=(unsigned char xdata*)Message;
 memcpy(RegK,&FactoryK,sizeof(FactoryK));
 memcpy(RegV,&FactoryV,sizeof(FactoryV));
 RtxCompletion=os_create_task(REGK);
 RtxCompletion=os_create_task(REGV);
 RtxCompletion=os_create_task(SERVOK);
 RtxCompletion=os_create_task(SERVOV);
 RtxCompletion=os_create_task(KEYBOARD);
 RtxCompletion=os_create_task(EXTEMP);
 RtxCompletion=os_create_task(INTEMP); 
 RtxCompletion=os_send_message(MEASURE,EXTEMP,EndWait);											//Zmeraj teplotu ....
 RegK->Reset=RegV->Reset=No;
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_IVL+K_SIG,100,NULL))
	  {
		 case	TMO_EVENT	:	if(++Cas.Sto==100)
											 {
											  Cas.Sto=0;
												if(++Cas.Sek==60)
												 {
												  Cas.Sek=0;
													if(++Cas.Min==60)
													 {
													  Cas.Min=0;
														if(++Cas.Hod==24)
														 {
														  Cas.Hod=24;
														 }	
													 }
												 }
											 }
											break;
		 case	SIG_EVENT	: break;
		}
	}
}

bit LED0;
bit LED1;
bit LED2;
bit LED3;

#define	K	10

extern unsigned int ADC_Conversion(char);

#pragma REGISTERBANK (3)

void Measure(void) _task_ MEASURE _priority_ 3
{
 signed char RtxCompletion;
 unsigned int Message;
 int Temp;
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_SIG+K_MBX+MEASURE,WFE,&Message))
	  {
		 case	SIG_EVENT	:	break;
		 case	MSG_EVENT	:	Temp=ADC_Conversion((unsigned char)Message);
											switch(Message)
											 {
												case	EXTEMP	:	Temp=-25; break;
												case	REGK		:	Temp=Tab1[Temp]-50;																			//Aka je teplota v rozsahu -50C az +50C
																				Temp=(int)Ekviterm[RegK->Vykurovacia_Krivka][Temp+50];	//Aplikujem ekvitermicku krivku
																				break;
												case	REGV		:	/*Temp=(Temp*0.09765625);*/
												case	EXH2OIN	:	Temp=Tab1[Temp];																				//Aka je teplota v rozsahu +0C az +100C
																				break;																	
											 }
											AD[Message]=Temp;											
											switch(Message)
											 {
												case	EXH2OIN	:	RtxCompletion=os_send_message(REGK,Temp+h2oin,EndWait);	break;
												default				:	RtxCompletion=os_send_message(Message,Temp,EndWait); break;		//Nahradit adresovanym posielanim hodnot ....
											 }
											break;
		}
	}
}

#pragma REGISTERBANK (0)

void RegulatorK(void) _task_ REGK _priority_ 1
{
 signed char RtxCompletion;
 unsigned int Message,Msg_h2o,Msg_reg;
 RegK->KA=(RegK->Kp*(1.0+RegK->dT*(0.01)/(2.0*RegK->Ti)));								//Konstanta KA prirastkoveho regulatora
 RegK->KB=(RegK->Kp*(1.0-RegK->dT*(0.01)/(2.0*RegK->Ti)));								//Konstanta KB prirastkoveho regulatora
 RegK->KC=(RegK->Kp*(RegK->Td/(RegK->dT*(0.01))));				     						//Konstanta KC prirastkoveho regulatora 
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG+K_MBX+REGK,RegK->dT,&Message))
	  {
		 case	TMO_EVENT	:	RtxCompletion=os_send_message(MEASURE,REGK,EndWait);
											RtxCompletion=os_send_message(MEASURE,EXH2OIN,EndWait);
											LED2=1;
											break;
		 case	MSG_EVENT	: switch(Message & h2oin)
											 {
												case	h2oin	:	Msg_h2o=Message & mask;	break;
												default			:	Msg_reg=Message; break;												
											 }
		 case	SIG_EVENT	:	RegK->E0=(int)Msg_reg-(int)Msg_h2o;		//???
											RegK->deltaT=(RegK->Tkomfort-RegK->Tutlm);
											if(Msg_reg>=RegK->Tmax) {RegK->Y0=RegK->Y1; RegK->E0=RegK->E1=RegK->E2=0;}										//Obmedzenie na teplotu Tmin..Tmax
											RegK->Y0=RegK->Y1+RegK->KA*RegK->E0-RegK->KB*RegK->E1+RegK->KC*RegK->E2;											//Vypocet trva cca. 1300us
											if((int)RegK->Y0<=(RegK->Servo_Min*K)) RegK->Y0=RegK->Servo_Min*K;
											if((int)RegK->Y0>=(RegK->Servo_Max*K)) RegK->Y0=RegK->Servo_Max*K;
											RegK->SetPosition=(int)RegK->Y0;
											RegK->E2=RegK->E1;
											RegK->E1=RegK->E0;
											RegK->Y1=RegK->Y0;
											LED2=0;
											break;
		}
	}
}

void RegulatorV(void) _task_ REGV _priority_ 1
{
 signed char RtxCompletion;
 //unsigned int Message,Msg_h2o,Msg_reg;
 unsigned int Message;
 RegV->KA=(RegV->Kp*(1.0+RegV->dT*(0.01)/(2.0*RegV->Ti)));								//Konstanta KA prirastkoveho regulatora
 RegV->KB=(RegV->Kp*(1.0-RegV->dT*(0.01)/(2.0*RegV->Ti)));								//Konstanta KB prirastkoveho regulatora
 RegV->KC=(RegV->Kp*(RegV->Td/(RegV->dT*(0.01))));				     						//Konstanta KC prirastkoveho regulatora 
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG+K_MBX+REGV,RegV->dT,&Message))
	  {
		 case	TMO_EVENT	:	RtxCompletion=os_send_message(MEASURE,REGV,EndWait);
											LED3=1;
											break;
		 case	MSG_EVENT	: /*switch(Message & h2oin)
											 {
												case	h2oin	:	Msg_h2o=Message & mask;	break;
												default			:	Msg_reg=Message; break;												
											 }*/
		 case	SIG_EVENT	:	RegV->E0=RegV->Tkomfort-(int)Message;
											if(Message>=RegV->Tmax) {RegV->Y0=RegV->Y1; RegV->E0=RegV->E1=RegV->E2=0;}										//Obmedzenie na teplotu Tmin..Tmax											
											RegV->Y0=RegV->Y1+RegV->KA*RegV->E0-RegV->KB*RegV->E1+RegV->KC*RegV->E2;											//Vypocet trva cca. 1300us
											if((int)RegV->Y0<=(RegV->Servo_Min*K)) RegV->Y0=RegV->Servo_Min*K;
											if((int)RegV->Y0>=(RegV->Servo_Max*K)) RegV->Y0=RegV->Servo_Max*K;
											RegV->SetPosition=(int)RegV->Y0;
											RegV->E2=RegV->E1;
											RegV->E1=RegV->E0;
											RegV->Y1=RegV->Y0;
											LED3=0;
											break;
		}
	}
}

sbit	Servo_k_Max	=	P1^0;
sbit	Servo_k_Min	=	P1^1;
sbit	PumpK				= P4^6;

void ServoK(void) _task_ SERVOK _priority_ 1
{
 signed char RtxCompletion,Actual0=OFF,Actual1=OFF;
 while(1)
  {
	 PumpK=RegK->Pump;
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG,K*10,NULL))
	  {
		 case	TMO_EVENT	:	//LED0=1;
											RegK->dPosition=RegK->SetPosition-RegK->ActualPosition;
											switch(Actual0=memcmp(&RegK->SetPosition,&RegK->ActualPosition,sizeof(RegK->ActualPosition)))
											 {
											  case	Zero	:	if(Actual0!=Actual1) {Servo_k_Max=Servo_k_Min=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL);}
																			break;
												case	Max		:	if(Actual0!=Actual1) {Servo_k_Min=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL); Servo_k_Max=ON;}
																			RegK->ActualPosition++;
																			break;
												case	Min		:	if(Actual0!=Actual1) {Servo_k_Max=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL); Servo_k_Min=ON;}
																			RegK->ActualPosition--;
																			break;
											 }
											Actual1=Actual0;
											//LED0=0;
											break;
		 //case	SIG_EVENT	:	Servo_k_Max=ON;
											break;
		 default				:	break;
		} 
	}
}

sbit	Servo_v_Max	=	P1^2;
sbit	Servo_v_Min	=	P1^3;
sbit	PumpV				= P4^7;

void ServoV(void) _task_ SERVOV _priority_ 1
{
 signed char RtxCompletion,Actual0=OFF,Actual1=OFF;
 while(1)
  {
	 PumpV=RegV->Pump;
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG,K*10,NULL))
	  {
		 case	TMO_EVENT	:	//LED1=1;
											RegV->dPosition=RegV->SetPosition-RegV->ActualPosition;
											switch(Actual0=memcmp(&RegV->SetPosition,&RegV->ActualPosition,sizeof(RegV->ActualPosition)))
											 {
											  case	Zero	:	if(Actual0!=Actual1) {Servo_v_Max=Servo_v_Min=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL);}
																			break;
												case	Max		:	if(Actual0!=Actual1) {Servo_v_Min=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL); Servo_v_Max=ON;}
																			RegV->ActualPosition++;
																			break;
												case	Min		:	if(Actual0!=Actual1) {Servo_v_Max=OFF; RtxCompletion=os_wait(K_TMO,Deathtime,NULL); Servo_v_Min=ON;}
																			RegV->ActualPosition--;
																			break;
											 }
											Actual1=Actual0;
											//LED1=0;
											break;
		 //case	SIG_EVENT	:	Servo_v_Max=ON;
											break;
		 default				:	break;
		}
	}
}

#define CNTLQ      0x11
#define CNTLS      0x13
#define DEL        0x7F
#define BACKSPACE  0x08
#define CR         0x0D
#define LF         0x0A
#define	ESC				 0x1B

code char Zoznam[]=
{
 "****************************************************************\r\n"
 "*  set RegK.Kp= - Nastav regulator                             *\r\n"
 "*  get          - Zisti nastavenie                             *\r\n"
 "*  temp         - Zobraz teploty                               *\r\n"
 "*  list         - Zobraz udaje                                 *\r\n" 
 "*  time         - Zobraz cas                                   *\r\n"
 "*  read         - Obnov data z EEPROM                          *\r\n" 
 "*  write        - Zalohuj data do EEPROM                       *\r\n"
 "*  set time n   - Nastav cas (HH:MM:SS)                        *\r\n"
 "*  set date n   - Nastav datum (DD:MM:YYYY)                    *\r\n" 
 "*  reset        - Reset regulatora (soft)                      *\r\n"
 "****************************************************************\r\n"
};

enum {Time,Set,List,Date,Temp,Reset=0xFF} Polozky;

void Keyboard(void) _task_ KEYBOARD _priority_ 0
{
 signed char RtxCompletion;
 unsigned char State,i,index,Buffer[50];
 int args;
 char Znak,Enter;
 State=Time;
 TMOD|=0x20;
 S0CON|=0x50;
 PCON|=0x80;
 TH1=TL1=0xFB;
 TR1=TI=1;
 RtxCompletion=os_attach_interrupt(4);
 sscanf(__TIME__,"%02bd:%02bd:%02bd",&Cas.Hod,&Cas.Min,&Cas.Sek);
 sscanf(__DATE2__,"%02bd/%02bd/%02d",&Cas.Mes,&Cas.Den,&Cas.Rok); Cas.Rok+=2000;
 memset(Buffer,'\0',sizeof(Buffer));
 printf("%s",Zoznam);
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG+K_INT,WFE,NULL))
	  {
		 case	TMO_EVENT	:	break;
		 case	SIG_EVENT	:	
		 case	INT_EVENT	:	if(RI)
											 {
											  RI=0;
												switch(Znak=S0BUF)
												 {
												  case	ESC				:	printf("                                                                \r"); State=Set; break;
												  case	'\r'			:	
													case	'\n'			:	Buffer[i++]='\n';
																						args=sscanf(Buffer,"set RegK.Kp=%f%c",&RegK->Kp,&Enter);
																						args=sscanf(Buffer,"set RegK.Ti=%f%c",&RegK->Ti,&Enter);
																						args=sscanf(Buffer,"set RegK.Td=%f%c",&RegK->Td,&Enter);
																						args=sscanf(Buffer,"set RegV.Kp=%f%c",&RegV->Kp,&Enter);
																						args=sscanf(Buffer,"set RegV.Ti=%f%c",&RegV->Ti,&Enter);
																						args=sscanf(Buffer,"set RegV.Td=%f%c",&RegV->Td,&Enter);
																						args=sscanf(Buffer,"set RegK.dT=%bd%c",&RegK->dT,&Enter);
																						args=sscanf(Buffer,"set RegV.dT=%bd%c",&RegV->dT,&Enter);
																						args=sscanf(Buffer,"set time %02bd:%02bd:%02bd%c",&Cas.Hod,&Cas.Min,&Cas.Sek,&Enter);
																						args=sscanf(Buffer,"set date %02bd.%02bd.%04d%c",&Cas.Den,&Cas.Mes,&Cas.Rok,&Enter);
																						if(RegK->dT>254) RegK->dT=254; if(RegK->dT<15) RegK->dT=15;
																						if(RegV->dT>254) RegV->dT=254; if(RegV->dT<15) RegV->dT=15;
																						if((memcmp(Buffer,"set RegK.Kp=",sizeof("set RegK.Kp=")-1)==NULL)||(memcmp(Buffer,"set RegK.Ti=",sizeof("set RegK.Ti=")-1)==NULL)||(memcmp(Buffer,"set RegK.Td=",sizeof("set RegK.Td=")-1)==NULL)||(memcmp(Buffer,"set RegK.dT=",sizeof("set RegK.dT=")-1)==NULL)) {RtxCompletion=os_delete_task(REGK); RtxCompletion=os_create_task(REGK);}
																						if((memcmp(Buffer,"set RegV.Kp=",sizeof("set RegV.Kp=")-1)==NULL)||(memcmp(Buffer,"set RegV.Ti=",sizeof("set RegV.Ti=")-1)==NULL)||(memcmp(Buffer,"set RegV.Td=",sizeof("set RegV.Td=")-1)==NULL)||(memcmp(Buffer,"set RegV.dT=",sizeof("set RegV.dT=")-1)==NULL)) {RtxCompletion=os_delete_task(REGV); RtxCompletion=os_create_task(REGV);}
																						if(memcmp(Buffer,"time\n",sizeof("time\n"))==0) State=Time;
																						if(memcmp(Buffer,"date\n",sizeof("date\n"))==0) State=Date;
																						if(memcmp(Buffer,"list\n",sizeof("list\n"))==0) State=List;
																						if(memcmp(Buffer,"temp\n",sizeof("temp\n"))==0) State=Temp;
																						if(memcmp(Buffer,"read\n",sizeof("read\n"))==0) RtxCompletion=os_send_message(INTEMP,READ,EndWait);
																						if(memcmp(Buffer,"write\n",sizeof("write\n"))==0) RtxCompletion=os_send_message(INTEMP,WRITE,EndWait);																						
																						if(memcmp(Buffer,"reset\n",sizeof("reset\n"))==0) {RegK->Reset=RegV->Reset='Y'; ((void (code*) (void)) 0x0000)();}
																						i=0;
																						memset(Buffer,'\0',sizeof(Buffer));
																						printf("\r\n%s",Zoznam);
																						break;
													//case	CNTLQ			: i++; break;
													case	BACKSPACE	: 
													case	DEL				: if(i--==0) i=0;
																						Buffer[i]='\0';
																						putchar('\r');
																						for(index=i; index<sizeof(Buffer); index++) putchar(Buffer[index]);
																						break;
													//case	CNTLS			:	i--; break;
													default					:	Buffer[i++]=Znak;
																						//printf("\r%s",Buffer);
																						break;
												 }
											 if(i>=sizeof(Buffer)) i=sizeof(Buffer);
											 if(i<=0x00) i=0x00;
											 putchar('\r');
											 for(index=0; index<i; index++) putchar(Buffer[index]);
											 }
											 switch(State)
											  {
												 case	Time	:	printf("\r%02bd:%02bd:%02bd\r",Cas.Hod,Cas.Min,Cas.Sek); break;
												 case	Date	:	printf("\r%02bd.%02bd.%04d\r",Cas.Den,Cas.Mes,Cas.Rok); break;
												 case Temp	:	printf("\rT2=%+02dC T3=%+02dC T4=%+02dC T5=%+02dC\r",AD[REGK],AD[REGV],AD[EXTEMP],(int)IntTemp); break;
												 case	Set		: break;
												 case	List	:	
																			printf("|------------------------------------------------------------|\n");
																			printf("|    RegK     |    RegV       |\n");
																			printf("|------------------------------------------------------------|\n");
																			printf("| Kp=%1.3E | Kp=%1.3E  |\n",RegK->Kp,RegV->Kp);
																			printf("| Ti=%1.3E | Ti=%1.3E  |\n",RegK->Ti,RegV->Ti);
																			printf("| Td=%1.3E | Td=%1.3E  |\n",RegK->Td,RegV->Td);
																			printf("| dT=%1.3E | dT=%1.3E  |\n",(float)RegK->dT,(float)RegV->dT);
																			printf("| KA=%1.3E | KA=%1.3E  |\n",(float)RegK->KA,(float)RegV->KA);
																			printf("| KB=%1.3E | KB=%1.3E  |\n",(float)RegK->KB,(float)RegV->KB);
																			printf("| KC=%1.3E | KC=%1.3E  |\n",(float)RegK->KC,(float)RegV->KC);
																			printf("| E0=%1.3E | E0=%1.3E  |\n",(float)RegK->E0,(float)RegV->E0);
																			printf("| E1=%1.3E | E1=%1.3E  |\n",(float)RegK->E1,(float)RegV->E1);
																			printf("| E2=%1.3E | E2=%1.3E  |\n",(float)RegK->E2,(float)RegV->E2);																			
																			printf("| Y0=%1.3E | Y0=%1.3E  |\n",(float)RegK->Y0,(float)RegV->Y0);
																			printf("| Y1=%1.3E | Y1=%1.3E  |\n",(float)RegK->Y1,(float)RegV->Y1);
																			printf("| Ek=%1.3E | Ek=%1.3E  |\n",(float)RegK->Vykurovacia_Krivka/10,(float)RegV->Vykurovacia_Krivka/10);
																			printf("|------------------------------------------------------------|\n");
																			State=Time;
																			break;
												 default		: printf("%s",Zoznam); break;
											  }
											break;
		}
	}
}

void Extemp(void) _task_ EXTEMP _priority_ 0
{
 signed char RtxCompletion;
 unsigned int Message;
 unsigned char Timer=0x00;
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG+K_MBX+EXTEMP,250,&Message))
	  {
		 case	MSG_EVENT	:	IntTemp=(int)Message;	break;
		 case	TMO_EVENT	:	if(++Timer==(4*60))																				//Meriam teplotu kazdych 60 sekund ...
											 {
											  Timer=0x00;
												RtxCompletion=os_send_message(MEASURE,EXTEMP,EndWait);	//Meriam teplotu cez AD, treba si vybrat co sa bude merat ...
											 }
											break;
		}
	}
}

//xdata t_rtx_onetasktab Task;

void Intemp(void) _task_ INTEMP _priority_ 0
{
 signed char RtxCompletion;
 unsigned int Message,Adresa;
 unsigned char *ptr,i,Timer=0x00;
 IntTemp=Get_Int_Temp(AddrDS1624A);																							//Meriam internu teplotu pre vlastne potreby
/* #ifdef SIMUL
 Adresa=0x0000;																						//memcpy(BakX,(unsigned char xdata*)Message,SizeMemBlock);	//Urobim kopiu "regulatora" do pamati ...																			
 ptr=memcpy(BakX,RegK,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!!																			
 for(i=0x00; i<SizeMemBlock; i++) Write_Eprom_AT24C32(AddrAT24c32,Adresa+i,ptr[i]);
 Adresa+=SizeMemBlock;
 ptr=memcpy(BakX,RegV,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!!
 for(i=0x00; i<SizeMemBlock; i++) Write_Eprom_AT24C32(AddrAT24c32,Adresa+i,ptr[i]); 
 #endif*/
 while(1)
  {
	 switch(RtxCompletion=os_wait(K_TMO+K_SIG+K_MBX+INTEMP,250,&Message))
	  {
		 case	TMO_EVENT	:	if(++Timer==(4*60))																				//Meriam teplotu kazdych 60 sekund ...
											 {
											  Timer=0x00;
												IntTemp=Get_Int_Temp(AddrDS1624A);											//Meriam internu teplotu pre vlastne potreby
											 }
											break;
		 case	SIG_EVENT	:
		 case	MSG_EVENT	:	switch(Message & (READ | WRITE))
											 {
											  case	READ	:	Adresa=0x0000;																						//memcpy(BakX,(unsigned char xdata*)Message,SizeMemBlock);	//Urobim kopiu "regulatora" do pamati ...																			
																			ptr=(unsigned char xdata*)BakX;														//Inicializujem ukazatel na kopiu regulatora ...
																			for(i=0x00; i<SizeMemBlock; i++) ptr[i]=Read_Eprom_AT24C32(AddrAT24c32,Adresa+i);					//V Menu Options je vypnute hlasenie linkera L16 uncalled segment !!!
																			#ifdef SAFE
																			RtxCompletion=os_delete_task(REGK);
																			#endif
																			ptr=memcpy(RegK,BakX,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!! 
																			#ifdef SAFE
																			RtxCompletion=os_create_task(REGK);
																			#endif
																			Adresa+=SizeMemBlock;
																			ptr=(unsigned char xdata*)BakX;														//Inicializujem ukazatel na kopiu regulatora ...
																			for(i=0x00; i<SizeMemBlock; i++) ptr[i]=Read_Eprom_AT24C32(AddrAT24c32,Adresa+i);					//V Menu Options je vypnute hlasenie linkera L16 uncalled segment !!!
																			#ifdef SAFE
																			RtxCompletion=os_delete_task(REGV);
																			#endif
																			ptr=memcpy(RegV,BakX,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!! 
																			#ifdef SAFE
																			RtxCompletion=os_create_task(REGV);
																			#endif
																			memset(BakX,'\0',SizeMemBlock);														//Vynulujem blok dat BakX
																			break;
												case	WRITE	:	Adresa=0x0000;																						//memcpy(BakX,(unsigned char xdata*)Message,SizeMemBlock);	//Urobim kopiu "regulatora" do pamati ...																			
																			ptr=memcpy(BakX,RegK,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!!																			
																			for(i=0x00; i<SizeMemBlock; i++) Write_Eprom_AT24C32(AddrAT24c32,Adresa+i,ptr[i]);
																			Adresa+=SizeMemBlock;
																			ptr=memcpy(BakX,RegV,SizeMemBlock);												//Urobim kopiu "regulatora" do pamati ... Opravit, kopiruje len jeden regulator, nema jeho adresu, bolo to posielane cez message !!!
																			for(i=0x00; i<SizeMemBlock; i++) Write_Eprom_AT24C32(AddrAT24c32,Adresa+i,ptr[i]);
																			break;
												default			:	Message&=~(READ|WRITE); break;							
											 }
											break;
		}
	}
}

void main(void)
{
 os_start_system(CLOCK);
}